#include<bits/stdc++.h>
using namespace std;
/*
f[i][j]代表取i个数砍j刀的所有方案中的最大值(i>j)
析例：s=‘1231’ 
f[1][0]=1 
f[2][0]=12 f[2][1]=1*2=2
f[3][0]=123 f[3][1]=max(1*23,12*3)=36 f[3][2]=1*2*3=6
f[4][0]=1231 f[4][1]=max(1*231,12*31,123*1)=372 f[4][2]=max(1*2*31,1*23*1,12*3*1)=62 f[4][3]=1*2*3*1=6

规律：f[i][j]=max(f[k][j-1] * rVal) as k from j to i-1,rVal代表取了k个数剩下的
*/

const int maxn = 51;
string s;

string dp[maxn][maxn];

int compare(string a, string b) {
    if (a.length() != b.length()) {
        return a.length() > b.length() ? 1 : -1;
    }
    return a.compare(b); // 长度相同时，字典序即数值序
}

//高精度乘法
string gj(string s1, string s2) {
    int la = s1.length();
    int lb = s2.length();
    int a[2005] = {0}, b[2005] = {0};  // 初始化避免脏数据
    
    // 字符串转数组并转置（低位在前，便于计算）
    for (int i = 0; i < la; ++i) {
        a[la - i] = s1[i] - '0';  // a[1]是个位，a[2]是十位，以此类推
    }
    for (int i = 0; i < lb; ++i) {
        b[lb - i] = s2[i] - '0';
    }
    
    int lc = la + lb;  // 乘积最大可能长度
    int c[4010] = {0};  // 存储乘积，初始化为0
    
    // 模拟竖式乘法：逐位相乘并处理进位
    for (int i = 1; i <= la; ++i) {
        for (int j = 1; j <= lb; ++j) {
            c[i + j - 1] += a[i] * b[j];  // 累加乘积到对应位
            c[i + j] += c[i + j - 1] / 10;  // 进位到高位
            c[i + j - 1] %= 10;  // 保留当前位的个位
        }
    }
    
    // 移除多余前导零
    while (lc > 1 && c[lc] == 0) {
        lc--;
    }
    
    // 数组转字符串（从最高位到最低位）
    string res;
    for (int i = lc; i >= 1; --i) {
        res += (c[i] + '0');
    }
    return res;
}

int main() {
	int n, k;
	cin >> n >> k;
	cin >> s;

	for (int i = 1; i <= n; ++i) {
		dp[i][0] = s.substr(0, i);
	}
	
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= k; ++j) {
            if(j>=i) break;
            dp[i][j] = "0";
			for (int l = j; l < i; ++l) {			
                string a=s.substr(l, i-l);	
                string temp = gj(dp[l][j-1],a);
                if(compare(temp, dp[i][j])>0){
                    dp[i][j] =temp;
                }
                // cout<<i<<" "<<j<<" "<<temp<<" "<<dp[i][j]<<endl;
			}
		}
	}
	cout << dp[n][k];
	return 0;
}
